/**
 * Notes: 项目服务类
 * Ver : CCMiniCloud Framework 2.0.1 ALL RIGHTS RESERVED BY cclinux0730 (wechat)
 * Date: 2023-08-30 19:20:00
 */

const BaseProjectService = require('./base_project_service.js');
const util = require('../../../framework/helpers/util.js');
const timeUtil = require('../../../framework/helpers/time_util.js');
const dataUtil = require('../../../framework/helpers/data_util.js');
const cloudUtil = require('../../../framework/cloud/cloud_util.js');
const ProjectModel = require('../model/project_model.js');
const appCode = require('../../../framework/core/app_code.js');
const AppError = require('../../../framework/core/app_error.js');
const InitCloudCollections = require('../init/init_cloud_collections.js');

// 全局变量，跟踪数据库初始化状态
let _dbInitialized = false;

class ProjectService extends BaseProjectService {

	/** 构造函数 */
	constructor() {
		super();
		this._model = new ProjectModel();
	}

	/**
	 * 确保数据库集合已初始化
	 * @returns {Promise<Boolean>} 初始化结果
	 */
	async ensureDbInitialized() {
		if (_dbInitialized) {
			console.log('[ProjectService] 数据库已初始化');
			return true;
		}

		try {
			console.log('[ProjectService] 初始化数据库集合...');
			const result = await InitCloudCollections.initCollections();
			console.log('[ProjectService] 数据库初始化结果:', result);
			
			if (result && result.code === 0) {
				_dbInitialized = true;
				return true;
			}
			
			return false;
		} catch (error) {
			console.error('[ProjectService] 数据库初始化失败:', error);
			return false;
		}
	}

	/**
	 * 获取项目模型
	 * @returns {ProjectModel}
	 */
	getModel() {
		return this._model;
	}

	/**
	 * 获取项目列表
	 * @param {Object} where 查询条件
	 * @param {Object} options 查询选项
	 * @returns {Promise<Object>} 项目列表数据
	 */
	async getProjectList(where, options = {}) {
		// 确保数据库初始化
		await this.ensureDbInitialized();
		
		// 处理查询条件
		if (!where) {
			where = {};
		}

		// 处理排序
		options.orderBy = options.orderBy || 'EDIT_TIME desc';

		// 调用基类方法获取列表
		let result = await this.getListOfModel(this, where, options);
		
		return result;
	}

	/**
	 * 获取项目详情
	 * @param {String} id 项目ID
	 * @returns {Promise<Object>} 项目详情数据
	 */
	async getProjectDetail(id) {
		// 确保数据库初始化
		await this.ensureDbInitialized();
		
		if (!id) {
			throw new AppError('项目ID不能为空', appCode.PARAM_REQUIRED);
		}
		
		let fields = '*';
		let where = {
			_id: id
		};
		
		let detail = await this._model.getOne(where, fields);
		if (!detail) {
			throw new AppError('项目不存在', appCode.DATA_NOT_EXIST);
		}
		
		return detail;
	}

	/**
	 * 创建项目
	 * @param {Object} data 项目数据
	 * @returns {Promise<String>} 创建的项目ID
	 */
	async createProject(data) {
		try {
			console.log('[createProject] 开始创建项目, 数据:', JSON.stringify(data, null, 2));
			
			// 确保数据库集合已初始化
			await this.ensureDbInitialized();
			
			if (!data) {
				throw new AppError('项目数据不能为空', appCode.PARAM_REQUIRED);
			}
			
			// 设置默认值
			data.CREATE_TIME = timeUtil.time();
			data.EDIT_TIME = timeUtil.time();
			
			// 检查必填字段
			if (!data.model) {
				throw new AppError('型号不能为空', appCode.PARAM_REQUIRED);
			}
			
			// 如果没有projectType，设置默认值
			if (!data.projectType) {
				console.log('[createProject] 项目类型为空，设置默认值：风机');
				data.projectType = '风机';
			}
			
			// 添加默认状态字段
			if (!data.level1) {
				data.level1 = 1; // 默认为待立项状态
			}
			
			if (!data.level2) {
				data.level2 = 'director'; // 默认为部门主管审核
			}
			
			// 特殊处理"霍尔"和"磁编"项目类型，移除不需要的产品参数字段
			if (data.projectType === '霍尔' || data.projectType === '磁编') {
				console.log('[createProject] 特殊项目类型:', data.projectType, '，移除产品参数字段');
				
				// 创建一个新对象，只包含基础字段
				const baseFields = [
					'_id', 'customerName', 'model', 'projectType', 'projectTypeName',
					'startDate', 'deadline', 'priority', 'description', 'hasSample',
					'sampleCount', 'sampleImages', 'attachments', 'isActive', 'isOverdue',
					'status', 'statusText', 'level1', 'level2', 'daysTillDeadline', 'CREATE_TIME', 'EDIT_TIME'
				];
				
				const cleanedData = {};
				for (let field of baseFields) {
					if (data[field] !== undefined) {
						cleanedData[field] = data[field];
					}
				}
				
				// 使用清理过的数据代替原始数据
				data = cleanedData;
				console.log('[createProject] 清理后的项目数据:', JSON.stringify(data, null, 2));
			}
			
			// 确保有model字段值
			if (!data.model) {
					throw new AppError('型号不能为空', appCode.PARAM_REQUIRED);
			}
			
			// 插入数据
			console.log('[createProject] 开始插入数据到数据库');
			let id = await this._model.insert(data);
			
			if (!id) {
				throw new AppError('创建项目失败', appCode.INTERNAL_ERROR);
			}
			
			console.log('[createProject] 创建项目成功，ID:', id);
			
			// 创建主分支
			try {
				console.log('[createProject] 开始创建主分支');
				
				// 准备分支数据
				const branchData = {
					projectId: id,
					name: '主分支',
					parentId: null,
					createdTime: timeUtil.time(),
					createdBy: this._userId,
					isMaster: true,
					isActive: true,
					completionPercentage: 0,
					status: {
						level1: data.level1 || 1,
						level2: data.level2 || 'director',
						level3: null,
						level4: null
					}
				};
				
				// 获取分支集合
				const cloudBase = require('../../../framework/cloud/cloud_base.js');
				const db = cloudBase.getDb();
				const collection = db.collection('plm_branch');
				
				// 插入分支数据
				await collection.add(branchData);
				console.log('[createProject] 主分支创建成功');
				
				// 更新项目记录，添加主分支ID
				await this._model.edit({ _id: id }, { masterBranchId: branchData._id });
				console.log('[createProject] 更新项目主分支ID成功');
			} catch (branchErr) {
				console.error('[createProject] 创建主分支失败:', branchErr);
				// 不影响项目创建的成功返回
			}
			
			return id;
		} catch (err) {
			console.error('[createProject] 创建项目失败:', err);
			
			// 如果是已知错误，直接抛出
			if (err instanceof AppError) {
				throw err;
			}
			
			// 未知错误，包装为应用错误
			throw new AppError('创建项目失败: ' + (err.message || err), appCode.INTERNAL_ERROR);
		}
	}

	/**
	 * 更新项目
	 * @param {String} id 项目ID
	 * @param {Object} data 更新数据
	 * @returns {Promise<Boolean>} 更新结果
	 */
	async updateProject(id, data) {
		if (!id) {
			throw new AppError('项目ID不能为空', appCode.PARAM_REQUIRED);
		}
		
		if (!data) {
			throw new AppError('更新数据不能为空', appCode.PARAM_REQUIRED);
		}
		
		// 设置更新时间
		data.EDIT_TIME = timeUtil.time();
		
		// 获取项目当前数据，确定项目类型
		let currentProject = await this.getProjectDetail(id);
		console.log('[updateProject] 当前项目数据:', currentProject);
		
		// 使用请求中的项目类型，如果没有则使用当前项目的类型
		const projectType = data.projectType || currentProject.projectType;
		console.log('[updateProject] 使用项目类型:', projectType);
		
		// 特殊处理"霍尔"和"磁编"项目类型，移除不需要的产品参数字段
		if (projectType === '霍尔' || projectType === '磁编') {
			console.log('[updateProject] 特殊项目类型:', projectType, '，移除产品参数字段');
			
			// 创建一个新对象，只包含基础字段
			const baseFields = [
				'_id', 'customerName', 'model', 'projectType', 'projectTypeName',
				'startDate', 'deadline', 'priority', 'description', 'hasSample',
				'sampleCount', 'sampleImages', 'attachments', 'isActive', 'isOverdue',
				'status', 'statusText', 'level1', 'daysTillDeadline', 'EDIT_TIME'
			];
			
			const cleanedData = {};
			for (let field of baseFields) {
				if (data[field] !== undefined) {
					cleanedData[field] = data[field];
				}
			}
			
			// 使用清理过的数据代替原始数据
			data = cleanedData;
			console.log('[updateProject] 清理后的项目数据:', data);
		}
		
		// 更新数据
		let where = {
			_id: id
		};
		
		let result = await this._model.edit(where, data);
		
		return result;
	}

	/**
	 * 删除项目
	 * @param {String} id 项目ID
	 * @returns {Promise<Boolean>} 删除结果
	 */
	async deleteProject(id) {
		if (!id) {
			throw new AppError('项目ID不能为空', appCode.PARAM_REQUIRED);
		}
		
		// 删除数据
		let where = {
			_id: id
		};
		
		let result = await this._model.del(where);
		
		return result;
	}
}

module.exports = ProjectService; 